const carStatus = {};
let messageStatus = {};
let costTable = {};
let pin_messageId= {};
let demandSize=0;



function createDemand() {
    let demand = [{}];

    const socket = new SockJS("http://localhost:8080/ws");

// 创建 STOMP 客户端
    const stompClient = Stomp.over(socket);

// 连接成功时的处理
    stompClient.connect({}, function (frame) {
        console.log("STOMP 连接已建立: " + frame);

        // 发送一条简单的消息到后端
        const messageToSend = {

            message: "hello"  // 发送的消息内容
        };

        stompClient.send("/app/demand", {}, JSON.stringify(messageToSend));
        console.log("已发送消息:", messageToSend);

        // 订阅接收消息
        stompClient.subscribe('/topic/messages', function (message) {
            const data = JSON.parse(message.body); // 解析收到的消息
            console.log("收到消息:", data);

            // demand = data;
            // for (var poiMarkerTableKey in poiMarkerTable) {
            //     poiMarkerTable[poiMarkerTableKey].hide();
            // }
            // for (var carMarkerTableKey in carMarkerTable) {
            //     carMarkerTable[carMarkerTableKey].hide();
            // }
            // for (let demandKey in demand) {
            //     let startIdM= demand[demandKey].startId;
            //     let endIdM= demand[demandKey].endId;
            //     let carIdM= demand[demandKey].carId;
            //
            //     poiMarkerTable[startIdM].show();
            //     poiMarkerTable[endIdM].show();
            //     carMarkerTable[carIdM].show();
            //     carMarkerTable[carIdM].setContent(icon.customVehicleIcon2);
            //
            //     carMarkerTable[carIdM].setLabel({
            //         content: demand[demandKey].goodsType,
            //         direction: 'top'
            //     });
            // }
            // pin_messageId={};
            // demandSize=demand.length;
            // processDemandsInBatches(demand, 1, 1000);


        });
    });

// 处理连接关闭
    stompClient.onclose = function (event) {
        console.log("STOMP 连接已关闭");
    };

// 处理错误
    stompClient.onerror = function (event) {
        console.error("STOMP 错误:", event);
    };



//     $.ajax({
//         url: 'api/demand',
//         type: 'GET',
//         success: function (data) {
//             demand = data;
//             for (var poiMarkerTableKey in poiMarkerTable) {
//                 poiMarkerTable[poiMarkerTableKey].hide();
//             }
//             for (var carMarkerTableKey in carMarkerTable) {
//                 carMarkerTable[carMarkerTableKey].hide();
//             }
//             for (let demandKey in demand) {
//                 let startIdM= demand[demandKey].startId;
//                 let endIdM= demand[demandKey].endId;
//                 let carIdM= demand[demandKey].carId;
//
//                 poiMarkerTable[startIdM].show();
//                 poiMarkerTable[endIdM].show();
//                 carMarkerTable[carIdM].show();
//                 carMarkerTable[carIdM].setContent(icon.customVehicleIcon2);
//
//                 carMarkerTable[carIdM].setLabel({
//                     content: demand[demandKey].goodsType,
//                     direction: 'top'
//                 });
//             }
//             pin_messageId={};
//             demandSize=demand.length;
//             processDemandsInBatches(demand, 1, 1000);
//         },
//         error: function () {
//             console.error('获取需求数据失败');
//         }
//     });
}


function processDemandsInBatches(demands, batchSize, delay) {
    var index = 0;

    function processBatch() {
        var batch = demands.slice(index, index + batchSize);
        batch.forEach(function (demandObj) {
            processSingleDemand(demandObj);
        });
        index += batchSize;
        if (index < demands.length) {
            setTimeout(processBatch, delay);
        }
    }

    processBatch();
}

//现在的demand只是简单的一个obj 里面都是一个的 可能会改成对某一个进行操作
function processSingleDemand(demand) {
    let driving = new AMap.Driving({
        autoSetView: false
    });
    // let startId = demand.startId;
    // let endId = demand.endId;
    let carId = demand.carId;
    let messageId = demand.messageId;
    let goodsType= demand.goodsType;

    let route = demand.route;
    let refuseOrNot = demand.refuseOrNot;
    //判断有几段 分情况 如果四个数都不为-1 则就是从车辆所在到最后一个数的poi 然后再加上三段 如果有一个为-1 则从车到倒数第二个 ；有两个则到倒数第三个 不会有其他情况
    let pathnum = 0;
    //i为有几个不为-1 可能取值 4 3 2
    for(let i = 0;i<4;i++){
        if(route[pathnum] != -1){
            pathnum++;
        }
    }
    //建最多有四个元素的数组 起始一个终点一个
    let startId = {};
    //let endId = {}; 好像不用endid starid[i+1]就是starid[i]的endid
    for(let i = 1;i<=pathnum;i++){
        startId[i] = route[pathnum - 1 - i];
    }


    //
    // let startPoi = poiMarkerTable[startId];
    // let endPoi = poiMarkerTable[endId];
    let car = carMarkerTable[carId];
    //
    // let start = startPoi.getPosition();
    // let end = endPoi.getPosition();
    let carPosition = car.getPosition();

    startId[0] = carPosition;
    let path = [];



    //用for循环往pathPromises里添加若干promise 同时也添加了path数组 根据pathnum的值来判断

    let pathPromises = [];

    for (let i = 0;i<pathnum;i++) {
        pathPromises.push(
            new Promise((resolve, reject) => {
                driving.search(startId[i], startId[i+1], function(status, result) {
                    if (status === 'complete') {
                        let path = extractPath(result);
                        drawPolyline(path, carId);
                        // 使用当前索引存储路径
                        path[pathPromises.length] = path;
                        resolve();
                    } else {
                        console.error('路径规划失败：' + result);
                        reject(result);
                    }
                });
            })
        );
    }

    // let pathPromises = [
    //     new Promise((resolve, reject) => {
    //         driving.search(carPosition, start, function(status, result) {
    //             if (status === 'complete') {
    //                 let path1 = extractPath(result);
    //                 drawPolyline(path1, carId);
    //                 path[0] = path1;
    //                 resolve();
    //             } else {
    //                 console.error('路径规划失败：' + result);
    //                 reject(result);
    //             }
    //         });
    //     }),
    //     new Promise((resolve, reject) => {
    //         driving.search(start, end, function(status, result) {
    //             if (status === 'complete') {
    //                 let path2 = extractPath(result);
    //                 drawPolyline(path2, carId);
    //                 path[1] = path2;
    //                 resolve();
    //             } else {
    //                 console.error('路径规划失败：' + result);
    //                 reject(result);
    //             }
    //         });
    //     })
    // ];
    //


    Promise.all(pathPromises).then(() => {
        //console.log(demand.demandKey)
        //调用开始 然后startprocess中再调用Movecar进行移动

        startProcess(carId, messageId, goodsType, path,demand);
    }).catch((error) => {
        console.error('路径规划失败：', error);
    });
}



// function createDemand() {
//     let demand = [{}];
//     $.ajax({
//         url: 'api/demand',
//         type: 'GET',
//         success: function (data) {
//             demand = data;
//             for (var poiMarkerTableKey in poiMarkerTable) {
//                 poiMarkerTable[poiMarkerTableKey].hide();
//             }
//             for (var carMarkerTableKey in carMarkerTable) {
//                 carMarkerTable[carMarkerTableKey].hide();
//             }
//             for (let demandKey in demand) {
//                 let startIdM= demand[demandKey].startId;
//                 let endIdM= demand[demandKey].endId;
//                 let carIdM= demand[demandKey].carId;
//                 poiMarkerTable[startIdM].show();
//                 poiMarkerTable[endIdM].show();
//                 carMarkerTable[carIdM].show();
//                 carMarkerTable[carIdM].setContent(icon.customVehicleIcon2);
//                 carMarkerTable[carIdM].setLabel({
//                     content: demand[demandKey].goodsType,
//                     direction: 'top'
//                 });
//             }
//             pin_messageId={};
//             demandSize=demand.length;
//             processDemandsInBatches(demand, 10, 1000);
//         },
//         error: function () {
//             console.error('获取需求数据失败');
//         }
//     });
// }
// function processDemandsInBatches(demands, batchSize, delay) {
//     var index = 0;
//
//     function processBatch() {
//         var batch = demands.slice(index, index + batchSize);
//         batch.forEach(function (demandObj) {
//             processSingleDemand(demandObj);
//         });
//         index += batchSize;
//         if (index < demands.length) {
//             setTimeout(processBatch, delay);
//         }
//     }
//
//     processBatch();
// }
// function processSingleDemand(demand) {
//     let driving = new AMap.Driving({
//         autoSetView: false
//     });
//     let startId = demand.startId;
//     let endId = demand.endId;
//     let carId = demand.carId;
//     let messageId = demand.messageId;
//     let goodsType= demand.goodsType;
//
//     let startPoi = poiMarkerTable[startId];
//     let endPoi = poiMarkerTable[endId];
//     let car = carMarkerTable[carId];
//
//     let start = startPoi.getPosition();
//     let end = endPoi.getPosition();
//     let carPosition = car.getPosition();
//
//     let path = [];
//
//     let pathPromises = [
//         new Promise((resolve, reject) => {
//             driving.search(carPosition, start, function(status, result) {
//                 if (status === 'complete') {
//                     let path1 = extractPath(result);
//                     drawPolyline(path1, carId);
//                     path[0] = path1;
//                     resolve();
//                 } else {
//                     console.error('路径规划失败：' + result);
//                     reject(result);
//                 }
//             });
//         }),
//         new Promise((resolve, reject) => {
//             driving.search(start, end, function(status, result) {
//                 if (status === 'complete') {
//                     let path2 = extractPath(result);
//                     drawPolyline(path2, carId);
//                     path[1] = path2;
//                     resolve();
//                 } else {
//                     console.error('路径规划失败：' + result);
//                     reject(result);
//                 }
//             });
//         })
//     ];
//
//     Promise.all(pathPromises).then(() => {
//         startProcess(carId, messageId, goodsType, path,demand);
//     }).catch((error) => {
//         console.error('路径规划失败：', error);
//     });
// }


async function changeLabel(car,newLabel){
    let label = car.getLabel().content;
    car.setLabel({
        content: newLabel, // 标签内容
        offset: new AMap.Pixel(0, 0), // 标签偏移量
        direction: 'top' // 标签方向
    });
    await new Promise(resolve => setTimeout(resolve, 2000));

    car.setLabel({
        content: label, // 标签内容
        offset: new AMap.Pixel(0, 0), // 标签偏移量
        direction: 'top' // 标签方向
    });
}

//这段代码定义了一个异步函数 moveCar，用于控制汽车沿指定路径移动。它接受两个参数：car（汽车对象）和 pathSegment（路径段）。函数内部返回一个新的 Promise，表示汽车移动的异步操作。
//async 是 JavaScript 中用于定义异步函数的关键字。当一个函数被标记为 async 时，它会返回一个 Promise，允许在函数内部使用 await 关键字来等待异步操作的结果。

async function moveCar(car, pathSegment,status1,status2,status3) {
    return new Promise(resolve => {
        car.moveAlong(pathSegment, {
            duration: 50,
            autoRotation: false,
            circlable: false
        });
        //console.log(car);

        if(status1!=0&&status1!=2) {
            //生成随机数 并计时器暂停
            let time1 = generateRandomNumber();
            console.log(time1);
            //     let newLabel;
            //     //确定赋值
            //     if (status1 == 4 || status1 == 7) {
            //         newLabel = '车辆正在保养';
            //     } else {
            //         newLabel = '车辆故障';
            //     }
            //     //在time1时暂停
            //     setTimeout(() => {
            //         car.pauseMove();
            //         //更改标签并改回
            //         changeLabel(car, newLabel);
            //         //继续移动
            //         car.resumeMove();
            //         console.log("车辆于第一段动画暂停并重新移动");
            //     }, time1);
            // }





            let label = car.getLabel().content;
            // 使用一个计时器，来模拟中途暂停
            setTimeout(() => {
                car.pauseMove();  // 假设有 stop 方法用于停止车辆
                console.log(car+"车辆第一段停止");
                if(status1==4||status1==7){
                    car.setLabel({
                        content: '车辆正在保养', // 标签内容
                        offset: new AMap.Pixel(0, 0), // 标签偏移量
                        direction: 'top' // 标签方向
                    });

                }
                else {
                    car.setLabel({
                        content: '车辆故障', // 标签内容
                        offset: new AMap.Pixel(0, 0), // 标签偏移量
                        direction: 'top' // 标签方向
                    });

                }




                // 等待一段时间后再继续移动
                setTimeout(() => {
                    // 继续移动
                    car. resumeMove();
                    car.setLabel({
                        content: label, // 标签内容
                        offset: new AMap.Pixel(0, 0), // 标签偏移量
                        direction: 'top' // 标签方向
                    });


                    console.log(car+"车辆第一段继续");
                    car.on('moveend', function () {
                        resolve();
                    });
                }, 2000); // 暂停2秒


            }, time1); // 在time1停止 在移动的过程中
        }





        if(status2!=0&&status2!=2) {
            //生成随机数 并计时器暂停
            let time2 = generateRandomNumber();
            console.log(time2)

            //     let newLabel;
            //     //确定赋值
            //     if (status2 == 4 || status2 == 7) {
            //         newLabel = '车辆正在保养';
            //     } else {
            //         newLabel = '车辆故障';
            //     }
            //     //在time2时暂停
            //     setTimeout(() => {
            //         car.pauseMove();
            //         //更改标签并改回
            //         changeLabel(car, newLabel);
            //         //继续移动
            //         car.resumeMove();
            //         console.log("车辆于第二段动画暂停并重新移动");
            //     }, time2);
            // }






            let label = car.getLabel().content;
            ;
            setTimeout(() => {
                car.pauseMove();  // 假设有 stop 方法用于停止车辆
                console.log(car+"车辆第二段停止");

                if(status1==4||status1==7){
                    car.setLabel({
                        content: '车辆正在保养', // 标签内容
                        offset: new AMap.Pixel(0, 0), // 标签偏移量
                        direction: 'top' // 标签方向
                    });

                }
                else {
                    car.setLabel({
                        content: '车辆故障', // 标签内容
                        offset: new AMap.Pixel(0, 0), // 标签偏移量
                        direction: 'top' // 标签方向
                    });

                }

                // 等待一段时间后再继续移动
                setTimeout(() => {
                    // 继续移动
                    car. resumeMove();
                    console.log(car+"车辆第二段继续");
                    car.setLabel({
                        content: label, // 标签内容
                        offset: new AMap.Pixel(0, 0), // 标签偏移量
                        direction: 'top' // 标签方向
                    });
                    car.on('moveend', function () {
                        resolve();
                    });
                }, 2000); // 暂2秒
            }, time2); // 在time2停止在移动的过程中
        }




        let label = car.getLabel().content;




        car.on('movealong', async function () {

            let action ;
            if(status3 == 1){
                action = '车辆正在装货';
            }
            else{
                action = '车辆正在卸货';
            }
            console.log(label,action,status3);

            //await changeLabel(car,action);

            car.setLabel({
                content: action, // 标签内容
                offset: new AMap.Pixel(0, 0), // 标签偏移量
                direction: 'top' // 标签方向
            });
            await new Promise(resolve => setTimeout(resolve, 2000));

            car.setLabel({
                content: label, // 标签内容
                offset: new AMap.Pixel(0, 0), // 标签偏移量
                direction: 'top' // 标签方向
            });

            resolve();
        },true);
    });
}

//生成10s以内随机数
function generateRandomNumber() {
    return Math.floor(Math.random() * 10000);
}



async function startProcess(carId, messageId, goodsType, path, demand) {

    let car = carMarkerTable[carId];
    let is_end = 0;
    for(let i = 0;i<path.length;i++){
        //判断是否是最后一段
        if(i == path.length-1){
            is_end = 1;
        }
        await askForStatus(carId, messageId,is_end, path);
        const carstu = carStatus[carId];

        const statusList0 = carStatus[carId];
        if (statusList0 && statusList0.length > 1) {
            console.log("第"+ i +"段成功获取");
        } else {
            console.error("第"+ i +"段carStatus未定义或数组长度不足");
        }

        console.log(carstu);

        await moveCar(car, path[0],carstu[0],carstu[1],carstu[2]);
        console.log("第"+ i +"段路径完成");

        await new Promise(resolve => setTimeout(resolve, 1000));
    }




    // await askForStatus(carId, messageId,0, path);
    // const carstu = carStatus[carId];
    //
    // const statusList0 = carStatus[carId];
    // if (statusList0 && statusList0.length > 1) {
    //     console.log("第一段成功获取");
    //     //console.log(statusList0);
    // } else {
    //     console.error("第一段carStatus未定义或数组长度不足");
    // }
    //
    // console.log(carstu);
    //
    // await moveCar(car, path[0],carstu[0],carstu[1],carstu[2]);
    // console.log('第一段路径完成');


    //await new Promise(resolve => setTimeout(resolve, 1000));//实现延迟，通常用于等待某个条件或状态的更新


    //第二段

    // await askForStatus(carId, messageId, path);
    // car = carMarkerTable[carId];
    // const carstu00 = carStatus[carId];
    //
    // let statusList1 = carStatus[carId];
    // if (statusList1 && statusList1.length > 1) {
    //     //let secondValue = statusList[1]; // 只在确认存在后访问
    //     console.log("第二段成功获取");
    //     console.log(statusList1);
    // } else {
    //     console.error("第二段carStatus未定义或数组长度不足");
    // }
    //
    // console.log(carstu00);
    // await moveCar(car, path[1],carstu00[0],carstu00[1],carstu00[2]);
    // console.log('第二段路径完成');


    // await new Promise(resolve => setTimeout(resolve, 1000));








    if (messageStatus[messageId] === 1) {
        const costData = await cost(messageId);
        pin_messageId[carId]=1;//？？？？为什么
    }
}


//目的是刷新地图上的汽车标记，同时确保兴趣点标记仍然可见。


function showMarkers() {
    let newCarMarkerTable={};
    for (var key in poiMarkerTable) {
        poiMarkerTable[key].show();
    }
    for (var key in carMarkerTable) {
        let newCarMarker=new AMap.Marker({
            map: map,
            position: carMarkerTable[key].getPosition(),
            title: carMarkerTable[key].type_name,
            content: icon.customVehicleIcon,
            offset: new AMap.Pixel(-25, -25)
        });
        carMarkerTable[key].hide();
        newCarMarkerTable[key]=newCarMarker;
    }
    carMarkerTable=newCarMarkerTable;
}


//将路线中的所有路径点收集到一个数组中，以便后续处理或绘制路径



function extractPath(result) {
    var steps = result.routes[0].steps;
    var path = [];
    for (var i = 0; i < steps.length; i++) {
        var step = steps[i];
        for (var j = 0; j < step.path.length; j++) {
            path.push(step.path[j]);
        }
    }
    return path;
}
let polylineTable = {};


//绘制车辆的行驶路径，并将该路径存储在一个与车辆 ID 关联的表中，以便后续操作。

function drawPolyline(path, carId) {
    var polyline = new AMap.Polyline({
        map: map,
        path: path,
        showDir: true,
        strokeColor: "#28F",
        strokeWeight: 6
    });

    if (!polylineTable[carId]) {
        polylineTable[carId] = [];
    }
    polylineTable[carId].push(polyline);
}


//通过 AJAX 请求获取汽车的状态，并返回一个 Promise。

function askForStatus(car_id, message_id,is_end,path) {
    return new Promise((resolve, reject) => {
        $.ajax({
            url: 'api/ask?car_id=' + car_id + '&message_id=' + message_id+ '&is_end=' + is_end,
            type: 'GET',
            success: function (data) {
                console.log(data);



                carStatus[car_id] = data.carStatus;


                if(data.DoneOrNot===1){
                    messageStatus[message_id] = 1;
                }
                resolve(data); // 解析Promise，传递数据
            },
            error: function (error) {
                reject(error); // 拒绝Promise，传递错误信息
            }
        });
    });
}





// function askForStatus(car_id, message_id,path) {
//     return new Promise((resolve, reject) => {
//         $.ajax({
//             url: 'api/ask?car_id=' + car_id + '&message_id=' + message_id,
//             type: 'GET',
//             success: function (data) {
//                 console.log(data);
//
//
//
//                 carStatus[car_id] = data.carStatus;
//
//
//                 if(data.DoneOrNot===1){
//                     messageStatus[message_id] = 1;
//                 }
//                 resolve(data); // 解析Promise，传递数据
//             },
//             error: function (error) {
//                 reject(error); // 拒绝Promise，传递错误信息
//             }
//         });
//     });
// }
let emptyDistanceTable = {};
let loadWasteTable = {};
let carUtilizationTable = {};

//花费函数

function cost(messageId) {
    return new Promise((resolve, reject) => {
        $.ajax({
            url: 'api/cost?message_id=' + messageId,
            type: 'GET',
            success: function (data) {
                costTable[messageId] = data.cost;
                emptyDistanceTable[messageId] = data.emptyDistance;
                loadWasteTable[messageId] = data.loadWaste;
                carUtilizationTable[messageId] = data.carUtilization;
                resolve(data); // 解析Promise，传递数据
            },
            error: function (error) {
                reject(error); // 拒绝Promise，传递错误信息
            }
        });
    });
}


//在网页上显示与车辆相关的成本信息


// function displayCost() {
//     let newWindow = window.open('', '_blank');
//     newWindow.document.write('<html><head><title>Cost List</title></head><body><ul>');
//
//     // 遍历 costTable 中的每个条目
//     for (let messageId in costTable) {
//         if (costTable.hasOwnProperty(messageId)) {
//             let cost = costTable[messageId];
//             newWindow.document.write('<li>ID: ' + messageId + ', 代价: ' + cost + ', 空跑距离: ' + emptyDistanceTable[messageId] + ', 载重浪费: ' + loadWasteTable[messageId] + ', 车辆使用率: ' + carUtilizationTable[messageId] + '</li>');
//         }
//     }
//
//     newWindow.document.write('</ul></body></html>');
//     newWindow.document.close();
// }


function displayCost() {
    let newWindow = window.open('', '_blank');
    newWindow.document.write(`
        <html>
            <head>
                <title>代价等数据</title>
                <style>
                title{
                
                }
                    table {
                        width: 100%;
                        border-collapse: collapse;
                        margin: 20px 0;
                    }
                    th, td {
                        border: 1px solid #ddd;
                        padding: 8px;
                        text-align: left;
                    }
                    th {
                        background-color: #f2f2f2;
                    }
                    tr:hover {
                        background-color: #f1f1f1;
                    }
                </style>
            </head>
            <body>
                <table>
                    <thead>
                        <tr>
                            <th>ID</th>
                            <th>代价</th>
                            <th>空跑距离</th>
                            <th>载重浪费</th>
                            <th>车辆使用率</th>
                        </tr>
                    </thead>
                    <tbody>
    `);

    // 遍历 costTable 中的每个条目
    for (let messageId in costTable) {
        if (costTable.hasOwnProperty(messageId)) {
            let cost = costTable[messageId];
            newWindow.document.write(`
                <tr>
                    <td>${messageId}</td>
                    <td>${cost}</td>
                    <td>${emptyDistanceTable[messageId]}</td>
                    <td>${loadWasteTable[messageId]}</td>
                    <td>${carUtilizationTable[messageId]}</td>
                </tr>
            `);
        }
    }

    newWindow.document.write(`
                    </tbody>
                </table>
            </body>
        </html>
    `);
    newWindow.document.close();
}





//隐藏所有存储在 polylineTable 中的折线

function clearPolylines(){
    for(var key in polylineTable){
        polylineTable[key].forEach(function(line) {
            line.hide();
        });
    }
}